// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.

#ifndef EIGEN_DENSESTORAGEBASE_H
#define EIGEN_DENSESTORAGEBASE_H

#if defined(EIGEN_INITIALIZE_MATRICES_BY_ZERO)
#define EIGEN_INITIALIZE_COEFFS
#define EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED                                                              \
	for (Index i = 0; i < base().size(); ++i)                                                                          \
		coeffRef(i) = Scalar(0);
#elif defined(EIGEN_INITIALIZE_MATRICES_BY_NAN)
#define EIGEN_INITIALIZE_COEFFS
#define EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED                                                              \
	for (Index i = 0; i < base().size(); ++i)                                                                          \
		coeffRef(i) = std::numeric_limits<Scalar>::quiet_NaN();
#else
#undef EIGEN_INITIALIZE_COEFFS
#define EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
#endif

namespace Eigen {

namespace internal {

template<int MaxSizeAtCompileTime>
struct check_rows_cols_for_overflow
{
	template<typename Index>
	EIGEN_DEVICE_FUNC static EIGEN_ALWAYS_INLINE void run(Index, Index)
	{
	}
};

template<>
struct check_rows_cols_for_overflow<Dynamic>
{
	template<typename Index>
	EIGEN_DEVICE_FUNC static EIGEN_ALWAYS_INLINE void run(Index rows, Index cols)
	{
		// http://hg.mozilla.org/mozilla-central/file/6c8a909977d3/xpcom/ds/CheckedInt.h#l242
		// we assume Index is signed
		Index max_index = (std::size_t(1) << (8 * sizeof(Index) - 1)) - 1; // assume Index is signed
		bool error = (rows == 0 || cols == 0) ? false : (rows > max_index / cols);
		if (error)
			throw_std_bad_alloc();
	}
};

template<typename Derived,
		 typename OtherDerived = Derived,
		 bool IsVector = bool(Derived::IsVectorAtCompileTime) && bool(OtherDerived::IsVectorAtCompileTime)>
struct conservative_resize_like_impl;

template<typename MatrixTypeA, typename MatrixTypeB, bool SwapPointers>
struct matrix_swap_impl;

} // end namespace internal

#ifdef EIGEN_PARSED_BY_DOXYGEN
namespace doxygen {

// This is a workaround to doxygen not being able to understand the inheritance logic
// when it is hidden by the dense_xpr_base helper struct.
// Moreover, doxygen fails to include members that are not documented in the declaration body of
// MatrixBase if we inherits MatrixBase<Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> >,
// this is why we simply inherits MatrixBase, though this does not make sense.

/** This class is just a workaround for Doxygen and it does not not actually exist. */
template<typename Derived>
struct dense_xpr_base_dispatcher;
/** This class is just a workaround for Doxygen and it does not not actually exist. */
template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
struct dense_xpr_base_dispatcher<Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>> : public MatrixBase
{};
/** This class is just a workaround for Doxygen and it does not not actually exist. */
template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
struct dense_xpr_base_dispatcher<Array<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>> : public ArrayBase
{};

} // namespace doxygen

/** \class PlainObjectBase
 * \ingroup Core_Module
 * \brief %Dense storage base class for matrices and arrays.
 *
 * This class can be extended with the help of the plugin mechanism described on the page
 * \ref TopicCustomizing_Plugins by defining the preprocessor symbol \c EIGEN_PLAINOBJECTBASE_PLUGIN.
 *
 * \tparam Derived is the derived type, e.g., a Matrix or Array
 *
 * \sa \ref TopicClassHierarchy
 */
template<typename Derived>
class PlainObjectBase : public doxygen::dense_xpr_base_dispatcher<Derived>
#else
template<typename Derived>
class PlainObjectBase : public internal::dense_xpr_base<Derived>::type
#endif
{
  public:
	enum
	{
		Options = internal::traits<Derived>::Options
	};
	typedef typename internal::dense_xpr_base<Derived>::type Base;

	typedef typename internal::traits<Derived>::StorageKind StorageKind;
	typedef typename internal::traits<Derived>::Scalar Scalar;

	typedef typename internal::packet_traits<Scalar>::type PacketScalar;
	typedef typename NumTraits<Scalar>::Real RealScalar;
	typedef Derived DenseType;

	using Base::ColsAtCompileTime;
	using Base::Flags;
	using Base::IsVectorAtCompileTime;
	using Base::MaxColsAtCompileTime;
	using Base::MaxRowsAtCompileTime;
	using Base::MaxSizeAtCompileTime;
	using Base::RowsAtCompileTime;
	using Base::SizeAtCompileTime;

	typedef Eigen::Map<Derived, Unaligned> MapType;
	typedef const Eigen::Map<const Derived, Unaligned> ConstMapType;
	typedef Eigen::Map<Derived, AlignedMax> AlignedMapType;
	typedef const Eigen::Map<const Derived, AlignedMax> ConstAlignedMapType;
	template<typename StrideType>
	struct StridedMapType
	{
		typedef Eigen::Map<Derived, Unaligned, StrideType> type;
	};
	template<typename StrideType>
	struct StridedConstMapType
	{
		typedef Eigen::Map<const Derived, Unaligned, StrideType> type;
	};
	template<typename StrideType>
	struct StridedAlignedMapType
	{
		typedef Eigen::Map<Derived, AlignedMax, StrideType> type;
	};
	template<typename StrideType>
	struct StridedConstAlignedMapType
	{
		typedef Eigen::Map<const Derived, AlignedMax, StrideType> type;
	};

  protected:
	DenseStorage<Scalar, Base::MaxSizeAtCompileTime, Base::RowsAtCompileTime, Base::ColsAtCompileTime, Options>
		m_storage;

  public:
	enum
	{
		NeedsToAlign = (SizeAtCompileTime != Dynamic) && (internal::traits<Derived>::Alignment > 0)
	};
	EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(NeedsToAlign)

	EIGEN_DEVICE_FUNC
	Base& base() { return *static_cast<Base*>(this); }
	EIGEN_DEVICE_FUNC
	const Base& base() const { return *static_cast<const Base*>(this); }

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR Index rows() const EIGEN_NOEXCEPT { return m_storage.rows(); }
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR Index cols() const EIGEN_NOEXCEPT { return m_storage.cols(); }

	/** This is an overloaded version of DenseCoeffsBase<Derived,ReadOnlyAccessors>::coeff(Index,Index) const
	 * provided to by-pass the creation of an evaluator of the expression, thus saving compilation efforts.
	 *
	 * See DenseCoeffsBase<Derived,ReadOnlyAccessors>::coeff(Index) const for details. */
	EIGEN_DEVICE_FUNC
	EIGEN_STRONG_INLINE const Scalar& coeff(Index rowId, Index colId) const
	{
		if (Flags & RowMajorBit)
			return m_storage.data()[colId + rowId * m_storage.cols()];
		else // column-major
			return m_storage.data()[rowId + colId * m_storage.rows()];
	}

	/** This is an overloaded version of DenseCoeffsBase<Derived,ReadOnlyAccessors>::coeff(Index) const
	 * provided to by-pass the creation of an evaluator of the expression, thus saving compilation efforts.
	 *
	 * See DenseCoeffsBase<Derived,ReadOnlyAccessors>::coeff(Index) const for details. */
	EIGEN_DEVICE_FUNC
	EIGEN_STRONG_INLINE const Scalar& coeff(Index index) const { return m_storage.data()[index]; }

	/** This is an overloaded version of DenseCoeffsBase<Derived,WriteAccessors>::coeffRef(Index,Index) const
	 * provided to by-pass the creation of an evaluator of the expression, thus saving compilation efforts.
	 *
	 * See DenseCoeffsBase<Derived,WriteAccessors>::coeffRef(Index,Index) const for details. */
	EIGEN_DEVICE_FUNC
	EIGEN_STRONG_INLINE Scalar& coeffRef(Index rowId, Index colId)
	{
		if (Flags & RowMajorBit)
			return m_storage.data()[colId + rowId * m_storage.cols()];
		else // column-major
			return m_storage.data()[rowId + colId * m_storage.rows()];
	}

	/** This is an overloaded version of DenseCoeffsBase<Derived,WriteAccessors>::coeffRef(Index) const
	 * provided to by-pass the creation of an evaluator of the expression, thus saving compilation efforts.
	 *
	 * See DenseCoeffsBase<Derived,WriteAccessors>::coeffRef(Index) const for details. */
	EIGEN_DEVICE_FUNC
	EIGEN_STRONG_INLINE Scalar& coeffRef(Index index) { return m_storage.data()[index]; }

	/** This is the const version of coeffRef(Index,Index) which is thus synonym of coeff(Index,Index).
	 * It is provided for convenience. */
	EIGEN_DEVICE_FUNC
	EIGEN_STRONG_INLINE const Scalar& coeffRef(Index rowId, Index colId) const
	{
		if (Flags & RowMajorBit)
			return m_storage.data()[colId + rowId * m_storage.cols()];
		else // column-major
			return m_storage.data()[rowId + colId * m_storage.rows()];
	}

	/** This is the const version of coeffRef(Index) which is thus synonym of coeff(Index).
	 * It is provided for convenience. */
	EIGEN_DEVICE_FUNC
	EIGEN_STRONG_INLINE const Scalar& coeffRef(Index index) const { return m_storage.data()[index]; }

	/** \internal */
	template<int LoadMode>
	EIGEN_STRONG_INLINE PacketScalar packet(Index rowId, Index colId) const
	{
		return internal::ploadt<PacketScalar, LoadMode>(m_storage.data() + (Flags & RowMajorBit
																				? colId + rowId * m_storage.cols()
																				: rowId + colId * m_storage.rows()));
	}

	/** \internal */
	template<int LoadMode>
	EIGEN_STRONG_INLINE PacketScalar packet(Index index) const
	{
		return internal::ploadt<PacketScalar, LoadMode>(m_storage.data() + index);
	}

	/** \internal */
	template<int StoreMode>
	EIGEN_STRONG_INLINE void writePacket(Index rowId, Index colId, const PacketScalar& val)
	{
		internal::pstoret<Scalar, PacketScalar, StoreMode>(m_storage.data() + (Flags & RowMajorBit
																				   ? colId + rowId * m_storage.cols()
																				   : rowId + colId * m_storage.rows()),
														   val);
	}

	/** \internal */
	template<int StoreMode>
	EIGEN_STRONG_INLINE void writePacket(Index index, const PacketScalar& val)
	{
		internal::pstoret<Scalar, PacketScalar, StoreMode>(m_storage.data() + index, val);
	}

	/** \returns a const pointer to the data array of this matrix */
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar* data() const { return m_storage.data(); }

	/** \returns a pointer to the data array of this matrix */
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar* data() { return m_storage.data(); }

	/** Resizes \c *this to a \a rows x \a cols matrix.
	 *
	 * This method is intended for dynamic-size matrices, although it is legal to call it on any
	 * matrix as long as fixed dimensions are left unchanged. If you only want to change the number
	 * of rows and/or of columns, you can use resize(NoChange_t, Index), resize(Index, NoChange_t).
	 *
	 * If the current number of coefficients of \c *this exactly matches the
	 * product \a rows * \a cols, then no memory allocation is performed and
	 * the current values are left unchanged. In all other cases, including
	 * shrinking, the data is reallocated and all previous values are lost.
	 *
	 * Example: \include Matrix_resize_int_int.cpp
	 * Output: \verbinclude Matrix_resize_int_int.out
	 *
	 * \sa resize(Index) for vectors, resize(NoChange_t, Index), resize(Index, NoChange_t)
	 */
	EIGEN_DEVICE_FUNC
	EIGEN_STRONG_INLINE void resize(Index rows, Index cols)
	{
		eigen_assert(EIGEN_IMPLIES(RowsAtCompileTime != Dynamic, rows == RowsAtCompileTime) &&
					 EIGEN_IMPLIES(ColsAtCompileTime != Dynamic, cols == ColsAtCompileTime) &&
					 EIGEN_IMPLIES(RowsAtCompileTime == Dynamic && MaxRowsAtCompileTime != Dynamic,
								   rows <= MaxRowsAtCompileTime) &&
					 EIGEN_IMPLIES(ColsAtCompileTime == Dynamic && MaxColsAtCompileTime != Dynamic,
								   cols <= MaxColsAtCompileTime) &&
					 rows >= 0 && cols >= 0 && "Invalid sizes when resizing a matrix or array.");
		internal::check_rows_cols_for_overflow<MaxSizeAtCompileTime>::run(rows, cols);
#ifdef EIGEN_INITIALIZE_COEFFS
		Index size = rows * cols;
		bool size_changed = size != this->size();
		m_storage.resize(size, rows, cols);
		if (size_changed)
			EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
#else
		m_storage.resize(rows * cols, rows, cols);
#endif
	}

	/** Resizes \c *this to a vector of length \a size
	 *
	 * \only_for_vectors. This method does not work for
	 * partially dynamic matrices when the static dimension is anything other
	 * than 1. For example it will not work with Matrix<double, 2, Dynamic>.
	 *
	 * Example: \include Matrix_resize_int.cpp
	 * Output: \verbinclude Matrix_resize_int.out
	 *
	 * \sa resize(Index,Index), resize(NoChange_t, Index), resize(Index, NoChange_t)
	 */
	EIGEN_DEVICE_FUNC
	inline void resize(Index size)
	{
		EIGEN_STATIC_ASSERT_VECTOR_ONLY(PlainObjectBase)
		eigen_assert(
			((SizeAtCompileTime == Dynamic && (MaxSizeAtCompileTime == Dynamic || size <= MaxSizeAtCompileTime)) ||
			 SizeAtCompileTime == size) &&
			size >= 0);
#ifdef EIGEN_INITIALIZE_COEFFS
		bool size_changed = size != this->size();
#endif
		if (RowsAtCompileTime == 1)
			m_storage.resize(size, 1, size);
		else
			m_storage.resize(size, size, 1);
#ifdef EIGEN_INITIALIZE_COEFFS
		if (size_changed)
			EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
#endif
	}

	/** Resizes the matrix, changing only the number of columns. For the parameter of type NoChange_t, just pass the
	 * special value \c NoChange as in the example below.
	 *
	 * Example: \include Matrix_resize_NoChange_int.cpp
	 * Output: \verbinclude Matrix_resize_NoChange_int.out
	 *
	 * \sa resize(Index,Index)
	 */
	EIGEN_DEVICE_FUNC
	inline void resize(NoChange_t, Index cols) { resize(rows(), cols); }

	/** Resizes the matrix, changing only the number of rows. For the parameter of type NoChange_t, just pass the
	 * special value \c NoChange as in the example below.
	 *
	 * Example: \include Matrix_resize_int_NoChange.cpp
	 * Output: \verbinclude Matrix_resize_int_NoChange.out
	 *
	 * \sa resize(Index,Index)
	 */
	EIGEN_DEVICE_FUNC
	inline void resize(Index rows, NoChange_t) { resize(rows, cols()); }

	/** Resizes \c *this to have the same dimensions as \a other.
	 * Takes care of doing all the checking that's needed.
	 *
	 * Note that copying a row-vector into a vector (and conversely) is allowed.
	 * The resizing, if any, is then done in the appropriate way so that row-vectors
	 * remain row-vectors and vectors remain vectors.
	 */
	template<typename OtherDerived>
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void resizeLike(const EigenBase<OtherDerived>& _other)
	{
		const OtherDerived& other = _other.derived();
		internal::check_rows_cols_for_overflow<MaxSizeAtCompileTime>::run(other.rows(), other.cols());
		const Index othersize = other.rows() * other.cols();
		if (RowsAtCompileTime == 1) {
			eigen_assert(other.rows() == 1 || other.cols() == 1);
			resize(1, othersize);
		} else if (ColsAtCompileTime == 1) {
			eigen_assert(other.rows() == 1 || other.cols() == 1);
			resize(othersize, 1);
		} else
			resize(other.rows(), other.cols());
	}

	/** Resizes the matrix to \a rows x \a cols while leaving old values untouched.
	 *
	 * The method is intended for matrices of dynamic size. If you only want to change the number
	 * of rows and/or of columns, you can use conservativeResize(NoChange_t, Index) or
	 * conservativeResize(Index, NoChange_t).
	 *
	 * Matrices are resized relative to the top-left element. In case values need to be
	 * appended to the matrix they will be uninitialized.
	 */
	EIGEN_DEVICE_FUNC
	EIGEN_STRONG_INLINE void conservativeResize(Index rows, Index cols)
	{
		internal::conservative_resize_like_impl<Derived>::run(*this, rows, cols);
	}

	/** Resizes the matrix to \a rows x \a cols while leaving old values untouched.
	 *
	 * As opposed to conservativeResize(Index rows, Index cols), this version leaves
	 * the number of columns unchanged.
	 *
	 * In case the matrix is growing, new rows will be uninitialized.
	 */
	EIGEN_DEVICE_FUNC
	EIGEN_STRONG_INLINE void conservativeResize(Index rows, NoChange_t)
	{
		// Note: see the comment in conservativeResize(Index,Index)
		conservativeResize(rows, cols());
	}

	/** Resizes the matrix to \a rows x \a cols while leaving old values untouched.
	 *
	 * As opposed to conservativeResize(Index rows, Index cols), this version leaves
	 * the number of rows unchanged.
	 *
	 * In case the matrix is growing, new columns will be uninitialized.
	 */
	EIGEN_DEVICE_FUNC
	EIGEN_STRONG_INLINE void conservativeResize(NoChange_t, Index cols)
	{
		// Note: see the comment in conservativeResize(Index,Index)
		conservativeResize(rows(), cols);
	}

	/** Resizes the vector to \a size while retaining old values.
	 *
	 * \only_for_vectors. This method does not work for
	 * partially dynamic matrices when the static dimension is anything other
	 * than 1. For example it will not work with Matrix<double, 2, Dynamic>.
	 *
	 * When values are appended, they will be uninitialized.
	 */
	EIGEN_DEVICE_FUNC
	EIGEN_STRONG_INLINE void conservativeResize(Index size)
	{
		internal::conservative_resize_like_impl<Derived>::run(*this, size);
	}

	/** Resizes the matrix to \a rows x \a cols of \c other, while leaving old values untouched.
	 *
	 * The method is intended for matrices of dynamic size. If you only want to change the number
	 * of rows and/or of columns, you can use conservativeResize(NoChange_t, Index) or
	 * conservativeResize(Index, NoChange_t).
	 *
	 * Matrices are resized relative to the top-left element. In case values need to be
	 * appended to the matrix they will copied from \c other.
	 */
	template<typename OtherDerived>
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void conservativeResizeLike(const DenseBase<OtherDerived>& other)
	{
		internal::conservative_resize_like_impl<Derived, OtherDerived>::run(*this, other);
	}

	/** This is a special case of the templated operator=. Its purpose is to
	 * prevent a default operator= from hiding the templated operator=.
	 */
	EIGEN_DEVICE_FUNC
	EIGEN_STRONG_INLINE Derived& operator=(const PlainObjectBase& other) { return _set(other); }

	/** \sa MatrixBase::lazyAssign() */
	template<typename OtherDerived>
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& lazyAssign(const DenseBase<OtherDerived>& other)
	{
		_resize_to_match(other);
		return Base::lazyAssign(other.derived());
	}

	template<typename OtherDerived>
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& operator=(const ReturnByValue<OtherDerived>& func)
	{
		resize(func.rows(), func.cols());
		return Base::operator=(func);
	}

	// Prevent user from trying to instantiate PlainObjectBase objects
	// by making all its constructor protected. See bug 1074.
  protected:
	EIGEN_DEVICE_FUNC
	EIGEN_STRONG_INLINE PlainObjectBase()
		: m_storage()
	{
		//       _check_template_params();
		//       EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
	}

#ifndef EIGEN_PARSED_BY_DOXYGEN
	// FIXME is it still needed ?
	/** \internal */
	EIGEN_DEVICE_FUNC
	explicit PlainObjectBase(internal::constructor_without_unaligned_array_assert)
		: m_storage(internal::constructor_without_unaligned_array_assert())
	{
		//       _check_template_params(); EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
	}
#endif

#if EIGEN_HAS_RVALUE_REFERENCES
	EIGEN_DEVICE_FUNC
	PlainObjectBase(PlainObjectBase&& other) EIGEN_NOEXCEPT : m_storage(std::move(other.m_storage)) {}

	EIGEN_DEVICE_FUNC
	PlainObjectBase& operator=(PlainObjectBase&& other) EIGEN_NOEXCEPT
	{
		_check_template_params();
		m_storage = std::move(other.m_storage);
		return *this;
	}
#endif

	/** Copy constructor */
	EIGEN_DEVICE_FUNC
	EIGEN_STRONG_INLINE PlainObjectBase(const PlainObjectBase& other)
		: Base()
		, m_storage(other.m_storage)
	{
	}
	EIGEN_DEVICE_FUNC
	EIGEN_STRONG_INLINE PlainObjectBase(Index size, Index rows, Index cols)
		: m_storage(size, rows, cols)
	{
		//       _check_template_params();
		//       EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
	}

#if EIGEN_HAS_CXX11
	/** \brief Construct a row of column vector with fixed size from an arbitrary number of coefficients. \cpp11
	 *
	 * \only_for_vectors
	 *
	 * This constructor is for 1D array or vectors with more than 4 coefficients.
	 * There exists C++98 analogue constructors for fixed-size array/vector having 1, 2, 3, or 4 coefficients.
	 *
	 * \warning To construct a column (resp. row) vector of fixed length, the number of values passed to this
	 * constructor must match the the fixed number of rows (resp. columns) of \c *this.
	 */
	template<typename... ArgTypes>
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
	PlainObjectBase(const Scalar& a0, const Scalar& a1, const Scalar& a2, const Scalar& a3, const ArgTypes&... args)
		: m_storage()
	{
		_check_template_params();
		EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, sizeof...(args) + 4);
		m_storage.data()[0] = a0;
		m_storage.data()[1] = a1;
		m_storage.data()[2] = a2;
		m_storage.data()[3] = a3;
		Index i = 4;
		auto x = { (m_storage.data()[i++] = args, 0)... };
		static_cast<void>(x);
	}

	/** \brief Constructs a Matrix or Array and initializes it by elements given by an initializer list of initializer
	 * lists \cpp11
	 */
	EIGEN_DEVICE_FUNC
	explicit EIGEN_STRONG_INLINE PlainObjectBase(const std::initializer_list<std::initializer_list<Scalar>>& list)
		: m_storage()
	{
		_check_template_params();

		size_t list_size = 0;
		if (list.begin() != list.end()) {
			list_size = list.begin()->size();
		}

		// This is to allow syntax like VectorXi {{1, 2, 3, 4}}
		if (ColsAtCompileTime == 1 && list.size() == 1) {
			eigen_assert(list_size == static_cast<size_t>(RowsAtCompileTime) || RowsAtCompileTime == Dynamic);
			resize(list_size, ColsAtCompileTime);
			std::copy(list.begin()->begin(), list.begin()->end(), m_storage.data());
		} else {
			eigen_assert(list.size() == static_cast<size_t>(RowsAtCompileTime) || RowsAtCompileTime == Dynamic);
			eigen_assert(list_size == static_cast<size_t>(ColsAtCompileTime) || ColsAtCompileTime == Dynamic);
			resize(list.size(), list_size);

			Index row_index = 0;
			for (const std::initializer_list<Scalar>& row : list) {
				eigen_assert(list_size == row.size());
				Index col_index = 0;
				for (const Scalar& e : row) {
					coeffRef(row_index, col_index) = e;
					++col_index;
				}
				++row_index;
			}
		}
	}
#endif // end EIGEN_HAS_CXX11

	/** \sa PlainObjectBase::operator=(const EigenBase<OtherDerived>&) */
	template<typename OtherDerived>
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PlainObjectBase(const DenseBase<OtherDerived>& other)
		: m_storage()
	{
		_check_template_params();
		resizeLike(other);
		_set_noalias(other);
	}

	/** \sa PlainObjectBase::operator=(const EigenBase<OtherDerived>&) */
	template<typename OtherDerived>
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PlainObjectBase(const EigenBase<OtherDerived>& other)
		: m_storage()
	{
		_check_template_params();
		resizeLike(other);
		*this = other.derived();
	}
	/** \brief Copy constructor with in-place evaluation */
	template<typename OtherDerived>
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PlainObjectBase(const ReturnByValue<OtherDerived>& other)
	{
		_check_template_params();
		// FIXME this does not automatically transpose vectors if necessary
		resize(other.rows(), other.cols());
		other.evalTo(this->derived());
	}

  public:
	/** \brief Copies the generic expression \a other into *this.
	 * \copydetails DenseBase::operator=(const EigenBase<OtherDerived> &other)
	 */
	template<typename OtherDerived>
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& operator=(const EigenBase<OtherDerived>& other)
	{
		_resize_to_match(other);
		Base::operator=(other.derived());
		return this->derived();
	}

	/** \name Map
	 * These are convenience functions returning Map objects. The Map() static functions return unaligned Map objects,
	 * while the AlignedMap() functions return aligned Map objects and thus should be called only with 16-byte-aligned
	 * \a data pointers.
	 *
	 * Here is an example using strides:
	 * \include Matrix_Map_stride.cpp
	 * Output: \verbinclude Matrix_Map_stride.out
	 *
	 * \see class Map
	 */
	//@{
	static inline ConstMapType Map(const Scalar* data) { return ConstMapType(data); }
	static inline MapType Map(Scalar* data) { return MapType(data); }
	static inline ConstMapType Map(const Scalar* data, Index size) { return ConstMapType(data, size); }
	static inline MapType Map(Scalar* data, Index size) { return MapType(data, size); }
	static inline ConstMapType Map(const Scalar* data, Index rows, Index cols)
	{
		return ConstMapType(data, rows, cols);
	}
	static inline MapType Map(Scalar* data, Index rows, Index cols) { return MapType(data, rows, cols); }

	static inline ConstAlignedMapType MapAligned(const Scalar* data) { return ConstAlignedMapType(data); }
	static inline AlignedMapType MapAligned(Scalar* data) { return AlignedMapType(data); }
	static inline ConstAlignedMapType MapAligned(const Scalar* data, Index size)
	{
		return ConstAlignedMapType(data, size);
	}
	static inline AlignedMapType MapAligned(Scalar* data, Index size) { return AlignedMapType(data, size); }
	static inline ConstAlignedMapType MapAligned(const Scalar* data, Index rows, Index cols)
	{
		return ConstAlignedMapType(data, rows, cols);
	}
	static inline AlignedMapType MapAligned(Scalar* data, Index rows, Index cols)
	{
		return AlignedMapType(data, rows, cols);
	}

	template<int Outer, int Inner>
	static inline typename StridedConstMapType<Stride<Outer, Inner>>::type Map(const Scalar* data,
																			   const Stride<Outer, Inner>& stride)
	{
		return typename StridedConstMapType<Stride<Outer, Inner>>::type(data, stride);
	}
	template<int Outer, int Inner>
	static inline typename StridedMapType<Stride<Outer, Inner>>::type Map(Scalar* data,
																		  const Stride<Outer, Inner>& stride)
	{
		return typename StridedMapType<Stride<Outer, Inner>>::type(data, stride);
	}
	template<int Outer, int Inner>
	static inline typename StridedConstMapType<Stride<Outer, Inner>>::type Map(const Scalar* data,
																			   Index size,
																			   const Stride<Outer, Inner>& stride)
	{
		return typename StridedConstMapType<Stride<Outer, Inner>>::type(data, size, stride);
	}
	template<int Outer, int Inner>
	static inline typename StridedMapType<Stride<Outer, Inner>>::type Map(Scalar* data,
																		  Index size,
																		  const Stride<Outer, Inner>& stride)
	{
		return typename StridedMapType<Stride<Outer, Inner>>::type(data, size, stride);
	}
	template<int Outer, int Inner>
	static inline typename StridedConstMapType<Stride<Outer, Inner>>::type Map(const Scalar* data,
																			   Index rows,
																			   Index cols,
																			   const Stride<Outer, Inner>& stride)
	{
		return typename StridedConstMapType<Stride<Outer, Inner>>::type(data, rows, cols, stride);
	}
	template<int Outer, int Inner>
	static inline typename StridedMapType<Stride<Outer, Inner>>::type Map(Scalar* data,
																		  Index rows,
																		  Index cols,
																		  const Stride<Outer, Inner>& stride)
	{
		return typename StridedMapType<Stride<Outer, Inner>>::type(data, rows, cols, stride);
	}

	template<int Outer, int Inner>
	static inline typename StridedConstAlignedMapType<Stride<Outer, Inner>>::type MapAligned(
		const Scalar* data,
		const Stride<Outer, Inner>& stride)
	{
		return typename StridedConstAlignedMapType<Stride<Outer, Inner>>::type(data, stride);
	}
	template<int Outer, int Inner>
	static inline typename StridedAlignedMapType<Stride<Outer, Inner>>::type MapAligned(
		Scalar* data,
		const Stride<Outer, Inner>& stride)
	{
		return typename StridedAlignedMapType<Stride<Outer, Inner>>::type(data, stride);
	}
	template<int Outer, int Inner>
	static inline typename StridedConstAlignedMapType<Stride<Outer, Inner>>::type
	MapAligned(const Scalar* data, Index size, const Stride<Outer, Inner>& stride)
	{
		return typename StridedConstAlignedMapType<Stride<Outer, Inner>>::type(data, size, stride);
	}
	template<int Outer, int Inner>
	static inline typename StridedAlignedMapType<Stride<Outer, Inner>>::type
	MapAligned(Scalar* data, Index size, const Stride<Outer, Inner>& stride)
	{
		return typename StridedAlignedMapType<Stride<Outer, Inner>>::type(data, size, stride);
	}
	template<int Outer, int Inner>
	static inline typename StridedConstAlignedMapType<Stride<Outer, Inner>>::type
	MapAligned(const Scalar* data, Index rows, Index cols, const Stride<Outer, Inner>& stride)
	{
		return typename StridedConstAlignedMapType<Stride<Outer, Inner>>::type(data, rows, cols, stride);
	}
	template<int Outer, int Inner>
	static inline typename StridedAlignedMapType<Stride<Outer, Inner>>::type
	MapAligned(Scalar* data, Index rows, Index cols, const Stride<Outer, Inner>& stride)
	{
		return typename StridedAlignedMapType<Stride<Outer, Inner>>::type(data, rows, cols, stride);
	}
	//@}

	using Base::setConstant;
	EIGEN_DEVICE_FUNC Derived& setConstant(Index size, const Scalar& val);
	EIGEN_DEVICE_FUNC Derived& setConstant(Index rows, Index cols, const Scalar& val);
	EIGEN_DEVICE_FUNC Derived& setConstant(NoChange_t, Index cols, const Scalar& val);
	EIGEN_DEVICE_FUNC Derived& setConstant(Index rows, NoChange_t, const Scalar& val);

	using Base::setZero;
	EIGEN_DEVICE_FUNC Derived& setZero(Index size);
	EIGEN_DEVICE_FUNC Derived& setZero(Index rows, Index cols);
	EIGEN_DEVICE_FUNC Derived& setZero(NoChange_t, Index cols);
	EIGEN_DEVICE_FUNC Derived& setZero(Index rows, NoChange_t);

	using Base::setOnes;
	EIGEN_DEVICE_FUNC Derived& setOnes(Index size);
	EIGEN_DEVICE_FUNC Derived& setOnes(Index rows, Index cols);
	EIGEN_DEVICE_FUNC Derived& setOnes(NoChange_t, Index cols);
	EIGEN_DEVICE_FUNC Derived& setOnes(Index rows, NoChange_t);

	using Base::setRandom;
	Derived& setRandom(Index size);
	Derived& setRandom(Index rows, Index cols);
	Derived& setRandom(NoChange_t, Index cols);
	Derived& setRandom(Index rows, NoChange_t);

#ifdef EIGEN_PLAINOBJECTBASE_PLUGIN
#include EIGEN_PLAINOBJECTBASE_PLUGIN
#endif

  protected:
	/** \internal Resizes *this in preparation for assigning \a other to it.
	 * Takes care of doing all the checking that's needed.
	 *
	 * Note that copying a row-vector into a vector (and conversely) is allowed.
	 * The resizing, if any, is then done in the appropriate way so that row-vectors
	 * remain row-vectors and vectors remain vectors.
	 */
	template<typename OtherDerived>
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void _resize_to_match(const EigenBase<OtherDerived>& other)
	{
#ifdef EIGEN_NO_AUTOMATIC_RESIZING
		eigen_assert(
			(this->size() == 0 || (IsVectorAtCompileTime ? (this->size() == other.size())
														 : (rows() == other.rows() && cols() == other.cols()))) &&
			"Size mismatch. Automatic resizing is disabled because EIGEN_NO_AUTOMATIC_RESIZING is defined");
		EIGEN_ONLY_USED_FOR_DEBUG(other);
#else
		resizeLike(other);
#endif
	}

	/**
	 * \brief Copies the value of the expression \a other into \c *this with automatic resizing.
	 *
	 * *this might be resized to match the dimensions of \a other. If *this was a null matrix (not already initialized),
	 * it will be initialized.
	 *
	 * Note that copying a row-vector into a vector (and conversely) is allowed.
	 * The resizing, if any, is then done in the appropriate way so that row-vectors
	 * remain row-vectors and vectors remain vectors.
	 *
	 * \sa operator=(const MatrixBase<OtherDerived>&), _set_noalias()
	 *
	 * \internal
	 */
	// aliasing is dealt once in internal::call_assignment
	// so at this stage we have to assume aliasing... and resising has to be done later.
	template<typename OtherDerived>
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& _set(const DenseBase<OtherDerived>& other)
	{
		internal::call_assignment(this->derived(), other.derived());
		return this->derived();
	}

	/** \internal Like _set() but additionally makes the assumption that no aliasing effect can happen (which
	 * is the case when creating a new matrix) so one can enforce lazy evaluation.
	 *
	 * \sa operator=(const MatrixBase<OtherDerived>&), _set()
	 */
	template<typename OtherDerived>
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& _set_noalias(const DenseBase<OtherDerived>& other)
	{
		// I don't think we need this resize call since the lazyAssign will anyways resize
		// and lazyAssign will be called by the assign selector.
		//_resize_to_match(other);
		// the 'false' below means to enforce lazy evaluation. We don't use lazyAssign() because
		// it wouldn't allow to copy a row-vector into a column-vector.
		internal::call_assignment_no_alias(
			this->derived(), other.derived(), internal::assign_op<Scalar, typename OtherDerived::Scalar>());
		return this->derived();
	}

	template<typename T0, typename T1>
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void
	_init2(Index rows, Index cols, typename internal::enable_if<Base::SizeAtCompileTime != 2, T0>::type* = 0)
	{
		const bool t0_is_integer_alike = internal::is_valid_index_type<T0>::value;
		const bool t1_is_integer_alike = internal::is_valid_index_type<T1>::value;
		EIGEN_STATIC_ASSERT(t0_is_integer_alike && t1_is_integer_alike,
							FLOATING_POINT_ARGUMENT_PASSED__INTEGER_WAS_EXPECTED)
		resize(rows, cols);
	}

	template<typename T0, typename T1>
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void
	_init2(const T0& val0, const T1& val1, typename internal::enable_if<Base::SizeAtCompileTime == 2, T0>::type* = 0)
	{
		EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 2)
		m_storage.data()[0] = Scalar(val0);
		m_storage.data()[1] = Scalar(val1);
	}

	template<typename T0, typename T1>
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void _init2(
		const Index& val0,
		const Index& val1,
		typename internal::enable_if<(!internal::is_same<Index, Scalar>::value) &&
										 (internal::is_same<T0, Index>::value) &&
										 (internal::is_same<T1, Index>::value) && Base::SizeAtCompileTime == 2,
									 T1>::type* = 0)
	{
		EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 2)
		m_storage.data()[0] = Scalar(val0);
		m_storage.data()[1] = Scalar(val1);
	}

	// The argument is convertible to the Index type and we either have a non 1x1 Matrix, or a dynamic-sized Array,
	// then the argument is meant to be the size of the object.
	template<typename T>
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void _init1(
		Index size,
		typename internal::enable_if<
			(Base::SizeAtCompileTime != 1 || !internal::is_convertible<T, Scalar>::value) &&
				((!internal::is_same<typename internal::traits<Derived>::XprKind, ArrayXpr>::value ||
				  Base::SizeAtCompileTime == Dynamic)),
			T>::type* = 0)
	{
		// NOTE MSVC 2008 complains if we directly put bool(NumTraits<T>::IsInteger) as the EIGEN_STATIC_ASSERT
		// argument.
		const bool is_integer_alike = internal::is_valid_index_type<T>::value;
		EIGEN_UNUSED_VARIABLE(is_integer_alike);
		EIGEN_STATIC_ASSERT(is_integer_alike, FLOATING_POINT_ARGUMENT_PASSED__INTEGER_WAS_EXPECTED)
		resize(size);
	}

	// We have a 1x1 matrix/array => the argument is interpreted as the value of the unique coefficient (case where
	// scalar type can be implicitly converted)
	template<typename T>
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void _init1(
		const Scalar& val0,
		typename internal::enable_if<Base::SizeAtCompileTime == 1 && internal::is_convertible<T, Scalar>::value,
									 T>::type* = 0)
	{
		EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 1)
		m_storage.data()[0] = val0;
	}

	// We have a 1x1 matrix/array => the argument is interpreted as the value of the unique coefficient (case where
	// scalar type match the index type)
	template<typename T>
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void _init1(
		const Index& val0,
		typename internal::enable_if<(!internal::is_same<Index, Scalar>::value) &&
										 (internal::is_same<Index, T>::value) && Base::SizeAtCompileTime == 1 &&
										 internal::is_convertible<T, Scalar>::value,
									 T*>::type* = 0)
	{
		EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 1)
		m_storage.data()[0] = Scalar(val0);
	}

	// Initialize a fixed size matrix from a pointer to raw data
	template<typename T>
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void _init1(const Scalar* data)
	{
		this->_set_noalias(ConstMapType(data));
	}

	// Initialize an arbitrary matrix from a dense expression
	template<typename T, typename OtherDerived>
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void _init1(const DenseBase<OtherDerived>& other)
	{
		this->_set_noalias(other);
	}

	// Initialize an arbitrary matrix from an object convertible to the Derived type.
	template<typename T>
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void _init1(const Derived& other)
	{
		this->_set_noalias(other);
	}

	// Initialize an arbitrary matrix from a generic Eigen expression
	template<typename T, typename OtherDerived>
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void _init1(const EigenBase<OtherDerived>& other)
	{
		this->derived() = other;
	}

	template<typename T, typename OtherDerived>
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void _init1(const ReturnByValue<OtherDerived>& other)
	{
		resize(other.rows(), other.cols());
		other.evalTo(this->derived());
	}

	template<typename T, typename OtherDerived, int ColsAtCompileTime>
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void _init1(const RotationBase<OtherDerived, ColsAtCompileTime>& r)
	{
		this->derived() = r;
	}

	// For fixed-size Array<Scalar,...>
	template<typename T>
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void _init1(
		const Scalar& val0,
		typename internal::enable_if<
			Base::SizeAtCompileTime != Dynamic && Base::SizeAtCompileTime != 1 &&
				internal::is_convertible<T, Scalar>::value &&
				internal::is_same<typename internal::traits<Derived>::XprKind, ArrayXpr>::value,
			T>::type* = 0)
	{
		Base::setConstant(val0);
	}

	// For fixed-size Array<Index,...>
	template<typename T>
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void _init1(
		const Index& val0,
		typename internal::enable_if<
			(!internal::is_same<Index, Scalar>::value) && (internal::is_same<Index, T>::value) &&
				Base::SizeAtCompileTime != Dynamic && Base::SizeAtCompileTime != 1 &&
				internal::is_convertible<T, Scalar>::value &&
				internal::is_same<typename internal::traits<Derived>::XprKind, ArrayXpr>::value,
			T*>::type* = 0)
	{
		Base::setConstant(val0);
	}

	template<typename MatrixTypeA, typename MatrixTypeB, bool SwapPointers>
	friend struct internal::matrix_swap_impl;

  public:
#ifndef EIGEN_PARSED_BY_DOXYGEN
	/** \internal
	 * \brief Override DenseBase::swap() since for dynamic-sized matrices
	 * of same type it is enough to swap the data pointers.
	 */
	template<typename OtherDerived>
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void swap(DenseBase<OtherDerived>& other)
	{
		enum { SwapPointers = internal::is_same<Derived, OtherDerived>::value && Base::SizeAtCompileTime == Dynamic };
		internal::matrix_swap_impl<Derived, OtherDerived, bool(SwapPointers)>::run(this->derived(), other.derived());
	}

	/** \internal
	 * \brief const version forwarded to DenseBase::swap
	 */
	template<typename OtherDerived>
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void swap(DenseBase<OtherDerived> const& other)
	{
		Base::swap(other.derived());
	}

	EIGEN_DEVICE_FUNC
	static EIGEN_STRONG_INLINE void _check_template_params()
	{
		EIGEN_STATIC_ASSERT(
			(EIGEN_IMPLIES(MaxRowsAtCompileTime == 1 && MaxColsAtCompileTime != 1,
						   (int(Options) & RowMajor) == RowMajor) &&
			 EIGEN_IMPLIES(MaxColsAtCompileTime == 1 && MaxRowsAtCompileTime != 1, (int(Options) & RowMajor) == 0) &&
			 ((RowsAtCompileTime == Dynamic) || (RowsAtCompileTime >= 0)) &&
			 ((ColsAtCompileTime == Dynamic) || (ColsAtCompileTime >= 0)) &&
			 ((MaxRowsAtCompileTime == Dynamic) || (MaxRowsAtCompileTime >= 0)) &&
			 ((MaxColsAtCompileTime == Dynamic) || (MaxColsAtCompileTime >= 0)) &&
			 (MaxRowsAtCompileTime == RowsAtCompileTime || RowsAtCompileTime == Dynamic) &&
			 (MaxColsAtCompileTime == ColsAtCompileTime || ColsAtCompileTime == Dynamic) &&
			 (Options & (DontAlign | RowMajor)) == Options),
			INVALID_MATRIX_TEMPLATE_PARAMETERS)
	}

	enum { IsPlainObjectBase = 1 };
#endif
  public:
	// These apparently need to be down here for nvcc+icc to prevent duplicate
	// Map symbol.
	template<typename PlainObjectType, int MapOptions, typename StrideType>
	friend class Eigen::Map;
	friend class Eigen::Map<Derived, Unaligned>;
	friend class Eigen::Map<const Derived, Unaligned>;
#if EIGEN_MAX_ALIGN_BYTES > 0
	// for EIGEN_MAX_ALIGN_BYTES==0, AlignedMax==Unaligned, and many compilers generate warnings for friend-ing a class
	// twice.
	friend class Eigen::Map<Derived, AlignedMax>;
	friend class Eigen::Map<const Derived, AlignedMax>;
#endif
};

namespace internal {

template<typename Derived, typename OtherDerived, bool IsVector>
struct conservative_resize_like_impl
{
#if EIGEN_HAS_TYPE_TRAITS
	static const bool IsRelocatable = std::is_trivially_copyable<typename Derived::Scalar>::value;
#else
	static const bool IsRelocatable = !NumTraits<typename Derived::Scalar>::RequireInitialization;
#endif
	static void run(DenseBase<Derived>& _this, Index rows, Index cols)
	{
		if (_this.rows() == rows && _this.cols() == cols)
			return;
		EIGEN_STATIC_ASSERT_DYNAMIC_SIZE(Derived)

		if (IsRelocatable &&
			((Derived::IsRowMajor && _this.cols() == cols) || // row-major and we change only the number of rows
			 (!Derived::IsRowMajor && _this.rows() == rows))) // column-major and we change only the number of columns
		{
			internal::check_rows_cols_for_overflow<Derived::MaxSizeAtCompileTime>::run(rows, cols);
			_this.derived().m_storage.conservativeResize(rows * cols, rows, cols);
		} else {
			// The storage order does not allow us to use reallocation.
			Derived tmp(rows, cols);
			const Index common_rows = numext::mini(rows, _this.rows());
			const Index common_cols = numext::mini(cols, _this.cols());
			tmp.block(0, 0, common_rows, common_cols) = _this.block(0, 0, common_rows, common_cols);
			_this.derived().swap(tmp);
		}
	}

	static void run(DenseBase<Derived>& _this, const DenseBase<OtherDerived>& other)
	{
		if (_this.rows() == other.rows() && _this.cols() == other.cols())
			return;

		// Note: Here is space for improvement. Basically, for conservativeResize(Index,Index),
		// neither RowsAtCompileTime or ColsAtCompileTime must be Dynamic. If only one of the
		// dimensions is dynamic, one could use either conservativeResize(Index rows, NoChange_t) or
		// conservativeResize(NoChange_t, Index cols). For these methods new static asserts like
		// EIGEN_STATIC_ASSERT_DYNAMIC_ROWS and EIGEN_STATIC_ASSERT_DYNAMIC_COLS would be good.
		EIGEN_STATIC_ASSERT_DYNAMIC_SIZE(Derived)
		EIGEN_STATIC_ASSERT_DYNAMIC_SIZE(OtherDerived)

		if (IsRelocatable &&
			((Derived::IsRowMajor && _this.cols() == other.cols()) || // row-major and we change only the number of rows
			 (!Derived::IsRowMajor &&
			  _this.rows() == other.rows()))) // column-major and we change only the number of columns
		{
			const Index new_rows = other.rows() - _this.rows();
			const Index new_cols = other.cols() - _this.cols();
			_this.derived().m_storage.conservativeResize(other.size(), other.rows(), other.cols());
			if (new_rows > 0)
				_this.bottomRightCorner(new_rows, other.cols()) = other.bottomRows(new_rows);
			else if (new_cols > 0)
				_this.bottomRightCorner(other.rows(), new_cols) = other.rightCols(new_cols);
		} else {
			// The storage order does not allow us to use reallocation.
			Derived tmp(other);
			const Index common_rows = numext::mini(tmp.rows(), _this.rows());
			const Index common_cols = numext::mini(tmp.cols(), _this.cols());
			tmp.block(0, 0, common_rows, common_cols) = _this.block(0, 0, common_rows, common_cols);
			_this.derived().swap(tmp);
		}
	}
};

// Here, the specialization for vectors inherits from the general matrix case
// to allow calling .conservativeResize(rows,cols) on vectors.
template<typename Derived, typename OtherDerived>
struct conservative_resize_like_impl<Derived, OtherDerived, true>
	: conservative_resize_like_impl<Derived, OtherDerived, false>
{
	typedef conservative_resize_like_impl<Derived, OtherDerived, false> Base;
	using Base::IsRelocatable;
	using Base::run;

	static void run(DenseBase<Derived>& _this, Index size)
	{
		const Index new_rows = Derived::RowsAtCompileTime == 1 ? 1 : size;
		const Index new_cols = Derived::RowsAtCompileTime == 1 ? size : 1;
		if (IsRelocatable)
			_this.derived().m_storage.conservativeResize(size, new_rows, new_cols);
		else
			Base::run(_this.derived(), new_rows, new_cols);
	}

	static void run(DenseBase<Derived>& _this, const DenseBase<OtherDerived>& other)
	{
		if (_this.rows() == other.rows() && _this.cols() == other.cols())
			return;

		const Index num_new_elements = other.size() - _this.size();

		const Index new_rows = Derived::RowsAtCompileTime == 1 ? 1 : other.rows();
		const Index new_cols = Derived::RowsAtCompileTime == 1 ? other.cols() : 1;
		if (IsRelocatable)
			_this.derived().m_storage.conservativeResize(other.size(), new_rows, new_cols);
		else
			Base::run(_this.derived(), new_rows, new_cols);

		if (num_new_elements > 0)
			_this.tail(num_new_elements) = other.tail(num_new_elements);
	}
};

template<typename MatrixTypeA, typename MatrixTypeB, bool SwapPointers>
struct matrix_swap_impl
{
	EIGEN_DEVICE_FUNC
	static EIGEN_STRONG_INLINE void run(MatrixTypeA& a, MatrixTypeB& b) { a.base().swap(b); }
};

template<typename MatrixTypeA, typename MatrixTypeB>
struct matrix_swap_impl<MatrixTypeA, MatrixTypeB, true>
{
	EIGEN_DEVICE_FUNC
	static inline void run(MatrixTypeA& a, MatrixTypeB& b)
	{
		static_cast<typename MatrixTypeA::Base&>(a).m_storage.swap(
			static_cast<typename MatrixTypeB::Base&>(b).m_storage);
	}
};

} // end namespace internal

} // end namespace Eigen

#endif // EIGEN_DENSESTORAGEBASE_H
